{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x05'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import struct\n",
    "struct.pack('>B',5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'\\x00\\x00\\x08\\x03\\x00\\x00\\xea`\\x00\\x00\\x00\\x1c\\x00\\x00\\x00\\x1c'\n",
      "(2051, 60000, 28, 28)\n"
     ]
    }
   ],
   "source": [
    "with open('./MNIST_data/train-images.idx3-ubyte', 'rb') as f:\n",
    "    buffer = f.read(4*4) #4个int\n",
    "    print(buffer)\n",
    "    head = struct.unpack('>iiii', buffer)\n",
    "    print(head)\n",
    "    length = head[1] * head[2] * head[3] # h1为图片数量，h2和h3为每一张图片的像素数量\n",
    "    buffer = f.read(length)\n",
    "    data = struct.unpack('>{}B'.format(length), buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "imgs = numpy.reshape(data, (head[1],head[2],head[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# imgs[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAOEUlEQVR4nO3dcYwV5bnH8d8jLUalENSIG9Ha22Bym0YXQUJiU6lNG4sm0JhWiHFp2mRJLAk1jam2q5DUGxujNGoicaukWLlCFS3Y1EsNS/TemDSuSBVLW6mhdMuGFTWyxEQqPPePHZoVd95Zzpk5c+D5fpLNOWeenTOPx/0xc847c15zdwE49Z1WdwMAWoOwA0EQdiAIwg4EQdiBID7Vyo2ZGR/9AxVzdxtreVN7djO7xsz+Yma7zey2Zp4LQLWs0XF2M5sg6a+SviZpQNLLkha7+58S67BnBypWxZ59jqTd7v6Wux+WtF7SgiaeD0CFmgn7BZL+MerxQLbsY8ys28z6zay/iW0BaFIzH9CNdajwicN0d++V1CtxGA/UqZk9+4CkC0c9ni5pX3PtAKhKM2F/WdIMM/ucmU2UtEjS5nLaAlC2hg/j3f0jM1smaYukCZLWuPsbpXUGoFQND701tDHeswOVq+SkGgAnD8IOBEHYgSAIOxAEYQeCIOxAEIQdCIKwA0EQdiAIwg4EQdiBIAg7EARhB4Ig7EAQhB0IgrADQRB2IAjCDgRB2IEgCDsQBGEHgmjplM049cyaNStZX7ZsWW6tq6srue5jjz2WrD/44IPJ+vbt25P1aNizA0EQdiAIwg4EQdiBIAg7EARhB4Ig7EAQzOKKpM7OzmS9r68vWZ88eXKZ7XzM+++/n6yfc845lW27neXN4trUSTVmtkfSsKQjkj5y99nNPB+A6pRxBt1X3P1ACc8DoEK8ZweCaDbsLun3ZvaKmXWP9Qtm1m1m/WbW3+S2ADSh2cP4K919n5mdJ+l5M/uzu784+hfcvVdSr8QHdECdmtqzu/u+7HZI0jOS5pTRFIDyNRx2MzvLzD5z7L6kr0vaWVZjAMrVzGH8NEnPmNmx5/lvd/+fUrpCy8yZkz4Y27hxY7I+ZcqUZD11Hsfw8HBy3cOHDyfrRePoc+fOza0VXetetO2TUcNhd/e3JF1WYi8AKsTQGxAEYQeCIOxAEIQdCIKwA0Fwiesp4Mwzz8ytXX755cl1H3/88WR9+vTpyXo29Jor9fdVNPx1zz33JOvr169P1lO99fT0JNe9++67k/V2lneJK3t2IAjCDgRB2IEgCDsQBGEHgiDsQBCEHQiCKZtPAQ8//HBubfHixS3s5MQUnQMwadKkZP2FF15I1ufNm5dbu/TSS5PrnorYswNBEHYgCMIOBEHYgSAIOxAEYQeCIOxAEIyznwRmzZqVrF977bW5taLrzYsUjWU/++yzyfq9996bW9u3b19y3VdffTVZf++995L1q6++OrfW7OtyMmLPDgRB2IEgCDsQBGEHgiDsQBCEHQiCsANB8L3xbaCzszNZ7+vrS9YnT57c8Lafe+65ZL3oevirrroqWU9dN/7II48k13377beT9SJHjhzJrX3wwQfJdYv+u4q+875ODX9vvJmtMbMhM9s5atnZZva8mb2Z3U4ts1kA5RvPYfwvJV1z3LLbJG119xmStmaPAbSxwrC7+4uS3j1u8QJJa7P7ayUtLLkvACVr9Nz4ae4+KEnuPmhm5+X9opl1S+pucDsASlL5hTDu3iupV+IDOqBOjQ697TezDknKbofKawlAFRoN+2ZJS7L7SyRtKqcdAFUpHGc3syckzZN0rqT9klZI+o2kX0u6SNJeSd9y9+M/xBvruUIexl9yySXJ+ooVK5L1RYsWJesHDhzIrQ0ODibXveuuu5L1p556KllvZ6lx9qK/+w0bNiTrN954Y0M9tULeOHvhe3Z3zzur4qtNdQSgpThdFgiCsANBEHYgCMIOBEHYgSD4KukSnH766cl66uuUJWn+/PnJ+vDwcLLe1dWVW+vv70+ue8YZZyTrUV100UV1t1A69uxAEIQdCIKwA0EQdiAIwg4EQdiBIAg7EATj7CWYOXNmsl40jl5kwYIFyXrRtMqAxJ4dCIOwA0EQdiAIwg4EQdiBIAg7EARhB4JgnL0Eq1atStbNxvxm338rGidnHL0xp52Wvy87evRoCztpD+zZgSAIOxAEYQeCIOxAEIQdCIKwA0EQdiAIxtnH6brrrsutdXZ2Jtctmh548+bNDfWEtNRYetH/kx07dpTdTu0K9+xmtsbMhsxs56hlK83sn2a2I/tp7tsZAFRuPIfxv5R0zRjLf+7undnP78ptC0DZCsPu7i9KercFvQCoUDMf0C0zs9eyw/ypeb9kZt1m1m9m6UnHAFSq0bCvlvR5SZ2SBiXdl/eL7t7r7rPdfXaD2wJQgobC7u773f2Iux+V9AtJc8ptC0DZGgq7mXWMevhNSTvzfhdAeygcZzezJyTNk3SumQ1IWiFpnpl1SnJJeyQtrbDHtpCax3zixInJdYeGhpL1DRs2NNTTqa5o3vuVK1c2/Nx9fX3J+u23397wc7erwrC7++IxFj9aQS8AKsTpskAQhB0IgrADQRB2IAjCDgTBJa4t8OGHHybrg4ODLeqkvRQNrfX09CTrt956a7I+MDCQW7vvvtyTPiVJhw4dStZPRuzZgSAIOxAEYQeCIOxAEIQdCIKwA0EQdiAIxtlbIPJXRae+ZrtonPyGG25I1jdt2pSsX3/99cl6NOzZgSAIOxAEYQeCIOxAEIQdCIKwA0EQdiAIxtnHycwaqknSwoULk/Xly5c31FM7uOWWW5L1O+64I7c2ZcqU5Lrr1q1L1ru6upJ1fBx7diAIwg4EQdiBIAg7EARhB4Ig7EAQhB0IgnH2cXL3hmqSdP755yfrDzzwQLK+Zs2aZP2dd97Jrc2dOze57k033ZSsX3bZZcn69OnTk/W9e/fm1rZs2ZJc96GHHkrWcWIK9+xmdqGZbTOzXWb2hpktz5afbWbPm9mb2e3U6tsF0KjxHMZ/JOmH7v6fkuZK+r6ZfUHSbZK2uvsMSVuzxwDaVGHY3X3Q3bdn94cl7ZJ0gaQFktZmv7ZWUvqcUAC1OqH37GZ2saSZkv4gaZq7D0oj/yCY2Xk563RL6m6uTQDNGnfYzWySpI2SfuDuB4su/jjG3Xsl9WbPkf4kC0BlxjX0Zmaf1kjQ17n709ni/WbWkdU7JA1V0yKAMhTu2W1kF/6opF3uvmpUabOkJZJ+lt2mv9c3sAkTJiTrN998c7Je9JXIBw8ezK3NmDEjuW6zXnrppWR927ZtubU777yz7HaQMJ7D+Csl3STpdTPbkS37sUZC/msz+56kvZK+VU2LAMpQGHZ3/z9JeW/Qv1puOwCqwumyQBCEHQiCsANBEHYgCMIOBGFFl2eWurGT+Ay61KWcTz75ZHLdK664oqltF52t2Mz/w9TlsZK0fv36ZP1k/hrsU5W7j/kHw54dCIKwA0EQdiAIwg4EQdiBIAg7EARhB4JgnL0EHR0dyfrSpUuT9Z6enmS9mXH2+++/P7nu6tWrk/Xdu3cn62g/jLMDwRF2IAjCDgRB2IEgCDsQBGEHgiDsQBCMswOnGMbZgeAIOxAEYQeCIOxAEIQdCIKwA0EQdiCIwrCb2YVmts3MdpnZG2a2PFu+0sz+aWY7sp/51bcLoFGFJ9WYWYekDnffbmafkfSKpIWSvi3pkLvfO+6NcVINULm8k2rGMz/7oKTB7P6wme2SdEG57QGo2gm9ZzeziyXNlPSHbNEyM3vNzNaY2dScdbrNrN/M+pvqFEBTxn1uvJlNkvSCpP9y96fNbJqkA5Jc0k81cqj/3YLn4DAeqFjeYfy4wm5mn5b0W0lb3H3VGPWLJf3W3b9Y8DyEHahYwxfC2MhXmz4qadfooGcf3B3zTUk7m20SQHXG82n8lyT9r6TXJR3NFv9Y0mJJnRo5jN8jaWn2YV7qudizAxVr6jC+LIQdqB7XswPBEXYgCMIOBEHYgSAIOxAEYQeCIOxAEIQdCIKwA0EQdiAIwg4EQdiBIAg7EARhB4Io/MLJkh2Q9PdRj8/NlrWjdu2tXfuS6K1RZfb22bxCS69n/8TGzfrdfXZtDSS0a2/t2pdEb41qVW8cxgNBEHYgiLrD3lvz9lPatbd27Uuit0a1pLda37MDaJ269+wAWoSwA0HUEnYzu8bM/mJmu83stjp6yGNme8zs9Wwa6lrnp8vm0Bsys52jlp1tZs+b2ZvZ7Zhz7NXUW1tM452YZrzW167u6c9b/p7dzCZI+qukr0kakPSypMXu/qeWNpLDzPZImu3utZ+AYWZflnRI0mPHptYys3skvevuP8v+oZzq7j9qk95W6gSn8a6ot7xpxr+jGl+7Mqc/b0Qde/Y5kna7+1vufljSekkLauij7bn7i5LePW7xAklrs/trNfLH0nI5vbUFdx909+3Z/WFJx6YZr/W1S/TVEnWE/QJJ/xj1eEDtNd+7S/q9mb1iZt11NzOGacem2cpuz6u5n+MVTuPdSsdNM942r10j0583q46wjzU1TTuN/13p7pdL+oak72eHqxif1ZI+r5E5AAcl3VdnM9k04xsl/cDdD9bZy2hj9NWS162OsA9IunDU4+mS9tXQx5jcfV92OyTpGY287Wgn+4/NoJvdDtXcz7+5+353P+LuRyX9QjW+dtk04xslrXP3p7PFtb92Y/XVqtetjrC/LGmGmX3OzCZKWiRpcw19fIKZnZV9cCIzO0vS19V+U1FvlrQku79E0qYae/mYdpnGO2+acdX82tU+/bm7t/xH0nyNfCL/N0k/qaOHnL7+Q9Ifs5836u5N0hMaOaz7l0aOiL4n6RxJWyW9md2e3Ua9/UojU3u/ppFgddTU25c08tbwNUk7sp/5db92ib5a8rpxuiwQBGfQAUEQdiAIwg4EQdiBIAg7EARhB4Ig7EAQ/w8+sGPVrnT8WgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "for i in range(5):\n",
    "    plt.imshow(imgs[i], cmap = 'gray')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "f:\\python37\\lib\\site-packages\\sklearn\\feature_extraction\\text.py:17: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Mapping, defaultdict\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import fetch_mldata\n",
    "mnist = fetch_mldata('MNIST original', data_home='./')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'DESCR': 'mldata.org dataset: mnist-original',\n",
       " 'COL_NAMES': ['label', 'data'],\n",
       " 'target': array([0., 0., 0., ..., 9., 9., 9.]),\n",
       " 'data': array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X,y = mnist['data'],mnist['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000, 784)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_digit = X[36000]\n",
    "some_digit_image = some_digit.reshape(28,28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(some_digit_image, cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[36000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = X[:60000],X[60000:],y[:60000],y[60000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([13991, 39491,  4357, ...,  9586, 42284,  1125])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将数据集合交叉洗牌，交叉验证时，每个子集合数据分布均匀，有些机器学习算法对训练实例的顺序敏感\n",
    "import numpy as np\n",
    "shuffle_index = np.random.permutation(60000)\n",
    "shuffle_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8), (60000, 784))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train,X_train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练一个二元分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 识别数字5，二元分类5或者非5\n",
    "# 创建目标向量\n",
    "y_train_5 = (y_train == 5)\n",
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, ..., False,  True, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [ True, False, False, ...,  True, False, False],\n",
       "       ...,\n",
       "       [False, False,  True, ..., False,  True, False],\n",
       "       [False, False, False, ...,  True, False, False],\n",
       "       [False, False, False, ..., False, False, False]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_5.reshape(20,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_5 = (y_test == 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SGD 梯度下降 分类器， 适合非常大的数据集，独立处理训练集数据，一次一个，适合在线学习，\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "\n",
    "sgd_clf = SGDClassifier(random_state = 42)\n",
    "sgd_clf.fit(X_train, y_train_5)\n",
    "\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 性能考核"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.9633 , 0.9625 , 0.96115])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器比评估回归器要困难得多\n",
    "\n",
    "# 3个折叠，正确率达到 95% 以上\n",
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把每张图都分类成非5\n",
    "from sklearn.base import BaseEstimator\n",
    "class Never5classifier(BaseEstimator):\n",
    "    def fit(self, X, y = None):\n",
    "        pass\n",
    "    def predict(self, X):\n",
    "        return np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False],\n",
       "       [False],\n",
       "       [False],\n",
       "       ...,\n",
       "       [False],\n",
       "       [False],\n",
       "       [False]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.9085 , 0.9098 , 0.91065])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "never_5_clf = Never5classifier()\n",
    "cross_val_score(never_5_clf, X_train, y_train_5, cv = 3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 评估分类器性能的更好方法是混淆矩阵\n",
    "# A类别实例被分为B类别次数\n",
    "# 想要知道分类器将数字3和数字5混淆多少次，通过混淆矩阵的5行3列\n",
    "from sklearn.model_selection import cross_val_predict\n",
    "\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 与 cross_val_score 相比\n",
    "* 同样执行交叉验证\n",
    "* 返回的不是评估分数，是每个折叠的预测\n",
    "* 每一个实例在模型预测时使用的数据，在训练期间从未见过"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[53605,   974],\n",
       "       [ 1287,  4134]], dtype=int64)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "confusion_matrix(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 行表示实际类别，列表示预测类别\n",
    "# 第一行 第一列 53272 被正确的分为 非5 ，真负类\n",
    "# 第一行 第二列 1307 被错误的分类成 5 ，假正类\n",
    "# 第二行 第一列 1077 张被错误的分为 非5， 假负类\n",
    "# 第二行 第二列 4344 张被正确的分在了5 ，真正类\n",
    "# 这种衡量方式太复杂，我们可以用更简单的指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54579,     0],\n",
       "       [    0,  5421]], dtype=int64)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_perfect_predictions = y_train_5\n",
    "confusion_matrix(y_train_5, y_train_perfect_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "## 正类预测的准确率 被称为分类器的精度\n",
    "\n",
    "\n",
    "$\n",
    "\\text{精度} = \\cfrac{TP}{TP + FP}\n",
    "$\n",
    "\n",
    "TP是真正类的数量，FP是假正类的数量\n",
    "\n",
    "\n",
    "$\n",
    "\\text{召回率TPR} = \\cfrac{TP}{TP + FN}\n",
    "$\n",
    "* 检测正类实例的比例\n",
    "FN是假负类的数量\n",
    "![jupyter](./zhaohui.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度和召回率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8093187157400157"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score\n",
    "\n",
    "precision_score(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.762589928057554"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 说明 检测一张图的时候，只有85%的概率是准确的，而且只有70%的数字5 被它检测出来\n",
    "# 精度和召回率合成单一指标，成为 F1 分数，谐波平均值\n",
    "# 平均值平等对待所有的值，谐波平均值会给予较低值更高的权重，只有召回率和精度都很高时，才能获得较高的F1分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "F_1 = \\cfrac{2}{\\cfrac{1}{\\text{precision}} + \\cfrac{1}{\\text{recall}}} = 2 \\times \\cfrac{\\text{precision}\\, \\times \\, \\text{recall}}{\\text{precision}\\, + \\, \\text{recall}} = \\cfrac{TP}{TP + \\cfrac{FN + FP}{2}}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7852597587615159"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "f1_score(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# F1分数对那些具有相近精度和召回率 分类器更有利，这不一定符合你的期望\n",
    "# 有时候你更关心精度，有时你能关心召回率\n",
    "# 训练一个分类器检测儿童可以放心观看的视频，你可能要求拦截了很多好的视频，低召回率，保留下来的都是安全的视频，高精度\n",
    "# 不能同时增加精度并减少召回率，反之亦然"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度/召回率权衡"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "![jupyter](./quanheng.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* SGDClassifier对每个实例基于决策函数计算一个分值，大于阀值为正类，否则为负类\n",
    "* 中间阀值右侧找到4个真正类 真5 ， 一个假正类 6， 精度为 4/5 80%\n",
    "* 在所有的6个 真正的5 中，分类器找到了4个，召回率为 4/6 67%\n",
    "* 提高阀值，向右移动，精度提高，召回降低\n",
    "* 反之阀值降低，召回提高，精度降低\n",
    "* SKlearn不可以直接设置阀值，可以访问决策分数，\n",
    "* SGDClassifier 默认阀值为0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何设置阀值\n",
    "\n",
    "# 用predict_proba得到每个实例属于正类的概率，然后对概率切一下。以LogisticRegression为例\n",
    "# clf = LogisticRegression()\n",
    "# clf.fit(X_train, y_train)\n",
    "# pred_proba = clf.predict_proba(X_test)[:, 1]\n",
    "# threshold = 0.75  # 阀值设置为0.75\n",
    "# pred_label = pred_proba > threshold\n",
    "\n",
    "# pred_proba是每个实例为真的概率\n",
    "# 假设阈值是0.75\n",
    "# pred_label里True就是概率大于0.75的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([91640.5921376])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores = sgd_clf.decision_function([some_digit])\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold = 0\n",
    "y_some_digit_pred = (y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提高阀值可以降低召回率，提高阀值到200000，就错了这个图\n",
    "threshold = 200000\n",
    "y_some_digit_pred = (y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 如何决定使用什么阀值\n",
    "# 返回决策值，而不是预测结果\n",
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,\n",
    "                             method=\"decision_function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000,)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.09064611, 0.0906309 , 0.09063242, ..., 1.        , 1.        ,\n",
       "        1.        ]),\n",
       " array([1.00000000e+00, 9.99815532e-01, 9.99815532e-01, ...,\n",
       "        3.68935621e-04, 1.84467810e-04, 0.00000000e+00]),\n",
       " array([-1763167.62545059, -1754524.62509729, -1753057.70237628, ...,\n",
       "          894295.69526238,   944254.40152459,  1070027.81333261]),\n",
       " array([False, False, False, ..., False, False, False]),\n",
       " array([-406910.45786266, -656616.32704609, -423076.25968257, ...,\n",
       "        -647595.15273461, -636834.99969902, -501406.61448318]))"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precisions, recalls, thresholds,y_train_5, y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib 绘制精度和召回相对于阀值的函数图\n",
    "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n",
    "    plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precision\", linewidth=2)\n",
    "    plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n",
    "    plt.xlabel(\"Threshold\", fontsize=16)\n",
    "    plt.legend(loc=\"upper left\", fontsize=16)\n",
    "    plt.ylim([0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n",
    "plt.xlim([-700000, 700000])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_precision_vs_recall(precisions, recalls):\n",
    "    plt.plot(recalls, precisions, \"b-\", linewidth=2)\n",
    "    plt.xlabel(\"召回\", fontsize=16)\n",
    "    plt.ylabel(\"精度\", fontsize=16)\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_precision_vs_recall(precisions, recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通过选择阀值来实现最佳的精度/召回率权衡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 目标设定为90%的精度，阀值大概在30000左右 , 设置了阀值为30000\n",
    "y_train_pred_90 = (y_scores > 30000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8504611330698287"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7144438295517432"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 获得了一个90%精度的分类器，但如果召回太低，精度再高，也不怎么有用\n",
    "* 如果工作中，需要99%的精度，你应该回应，召回率是多少？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 本质是 真正类率tpr和假正类率fpr（错误的分为正类的负类实例比例）\n",
    "# 与召回/精度曲线非常相似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "\n",
    "fpr, tpr, thresholds = roc_curve(y_train_5, y_scores) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-406910.45786266, -656616.32704609, -423076.25968257, ...,\n",
       "       -647595.15273461, -636834.99969902, -501406.61448318])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_roc_curve(fpr, tpr, label=None):\n",
    "    plt.plot(fpr, tpr, linewidth=2, label=label)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "    plt.xlabel('假正类率', fontsize=16)\n",
    "    plt.ylabel('真正类率', fontsize=16)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_roc_curve(fpr, tpr)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-406910.45786266, -656616.32704609, -423076.25968257, ...,\n",
       "       -647595.15273461, -636834.99969902, -501406.61448318])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9622902086771697"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算曲线下面积AUC，虚线是随机分类0.5到1\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "roc_auc_score(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 召回率TPR越高，分类器的假正类FPR就越多\n",
    "* 虚线表示纯随机分类器的ROC曲线，好的分类器应该远离这条线，向左上角\n",
    "* 是使用精度/召回率 PR曲线，还是使用ROC，关键在于 正类非常少或者更关注假正类而不是假负类，选择PR，反之ROC\n",
    "* 例如：前面例子ROC曲线很不错是因为跟负类 非5 相比， 正类 数据5 数量真的很少"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练随机森林分类器，比较SGD分类器的ROC曲线和ROC AUC分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 获取训练集中每个实例的分数\n",
    "* RandomForestClassifier 没有descision_function(),但是拥有dict_proda()方法，sklearn中分类器都有这两个中的一个\n",
    "* dict_proda返回一个矩阵，每行一个实例，每列代表一个类别的概率，比如这个图片 70%是5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "f:\\python37\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "forest_clf = RandomForestClassifier(n_estimators=10, random_state=42)\n",
    "y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3,\n",
    "                                    method=\"predict_proba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 0. ],\n",
       "       [0.9, 0.1],\n",
       "       [1. , 0. ],\n",
       "       ...,\n",
       "       [1. , 0. ],\n",
       "       [1. , 0. ],\n",
       "       [1. , 0. ]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_probas_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制ROC曲线，需要决策值不是概率，直接使用正类的概率作为决策值：\n",
    "y_scores_forest = y_probas_forest[:, 1] \n",
    "fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5,y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(fpr, tpr, \"b:\", linewidth=2, label=\"SGD\")\n",
    "plot_roc_curve(fpr_forest, tpr_forest, \"Random Forest\")\n",
    "plt.legend(loc=\"lower right\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9913690803822869"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rand 比SGD 好很多，ROC AUC的分数也高很多\n",
    "roc_auc_score(y_train_5, y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.983206106870229"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 再看一下 精度和召回率 也很高\n",
    "y_train_pred_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3)\n",
    "precision_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.831580889134846"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 选择合适的指标利用交叉验证来对分类器进行评估\n",
    "* 选择满足需求的精度/召回率权衡\n",
    "* 使用ROC曲线和ROC AUC分数比较多个模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多类别分类器\n",
    "* 尝试5 之外的检测\n",
    "* 多类别分类器 区分两个以上的类别\n",
    "* 随机森里和朴素贝叶斯可以直接处理多个类别\n",
    "* 支持向量机svm和线性分类器只可以处理二元分类器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 解决方案\n",
    "1. 将数字图片分类0到9，训练10个二元分类器，每个数字一个，检测一张图片时，获取每个分类器的决策分数，哪个最高属于哪个，称为一对多OvA\n",
    "2. 为每一对数字训练一个二元分类器，区分0，1 区分0，2 区分1，2 称为一对一OvO策略，存在N个类别，需要N*（N-1）/2个分类器，最后看哪个类别获胜最多"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 优缺点\n",
    "* OvO 只需要用到部分训练集对其必须区分两个类别进行训练\n",
    "* 对于较小训练集合OvO比较有优势， 大训练集合 OvA 速度快，所以OvA更常用，比如svm 在数据规模扩大时表现糟糕\n",
    "* sklearn 检查到使用二元分类算法进行多类别分类任务，会自动运行OvA，SVM分类器除外"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.fit(X_train, y_train)\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-167110.39159291, -545962.28373169, -354550.20753409,\n",
       "        -320945.4963378 , -428645.87713266,   91640.5921376 ,\n",
       "        -804203.95888043, -322709.46604097, -752671.45901611,\n",
       "        -552724.62199337]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_digit_scores = sgd_clf.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(some_digit_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 目标类别列表会存储在classes_这个属性中，按值大小排列，\n",
    "sgd_clf.classes_ # 分类的列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.classes_[np.argmax(some_digit_scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用OvO策略，一对一或者一对多\n",
    "from sklearn.multiclass import OneVsOneClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5, tol=-np.infty, random_state=42))\n",
    "ovo_clf.fit(X_train, y_train)\n",
    "ovo_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ovo_clf.estimators_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "            max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1,\n",
       "            oob_score=False, random_state=42, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用随机森林\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "forest_clf = RandomForestClassifier(n_estimators=10, random_state=42)\n",
    "forest_clf.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "forest_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 0. , 0. , 0. , 0. , 0.9, 0. , 0. , 0.1, 0. ]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机森林直接将实例分为多个类别，调用predict_proba()可以获得分类器将每个实例分类为每个类别的概率列表\n",
    "forest_clf.predict_proba([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.87267546, 0.87664383, 0.85502825])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用交叉验证评估SGD的准确率\n",
    "cross_val_score(sgd_clf, X_train, y_train, cv=3 ,scoring='accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.91066787, 0.9099455 , 0.90723609])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将输入进行简单缩放 ，可以得到准确率 90 %以上\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()\n",
    "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n",
    "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 错误分析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 项目流程\n",
    "1. 探索数据准备的选项\n",
    "2. 尝试多个模型\n",
    "3. 选择最佳模型并用GridSearchCV对参数进行微调\n",
    "4. 尽可能自动化\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 确定了一个相对合适的模型，进一步优化，分析其错误类型\n",
    "* 查看混淆矩阵\n",
    "* 使用cross_val_predict()进行预测\n",
    "* 调用confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "f:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5735,    2,   23,   10,   15,   45,   42,    7,   40,    4],\n",
       "       [   2, 6482,   50,   22,    5,   39,    7,   11,  113,   11],\n",
       "       [  57,   38, 5321,  104,   85,   27,   90,   61,  158,   17],\n",
       "       [  48,   39,  140, 5348,    2,  232,   33,   55,  133,  101],\n",
       "       [  21,   30,   41,   12, 5354,    9,   47,   34,   77,  217],\n",
       "       [  79,   45,   36,  181,   78, 4591,  112,   25,  177,   97],\n",
       "       [  33,   28,   44,    2,   45,   88, 5615,    9,   53,    1],\n",
       "       [  24,   21,   69,   28,   56,   12,    8, 5791,   14,  242],\n",
       "       [  59,  154,   72,  147,   13,  165,   58,   28, 5014,  141],\n",
       "       [  38,   35,   27,   89,  145,   38,    2,  194,   75, 5306]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)\n",
    "conf_mx = confusion_matrix(y_train, y_train_pred)\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib的matshow 函数来查看混淆矩阵的图像表示\n",
    "plt.matshow(conf_mx, cmap = plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 看起来不错，大多数图片都在主对角线上，说明它们被正确分类\n",
    "# 数字5 看起来比较暗，说明1. 数字5图片较少  2. 分类器在数字5上执行效果不如其他数字上好\n",
    "# 假设把焦点放在错误上，为取得错误率，而不是错误绝对值，需要将混淆矩阵中每个值除以相应类别中的图片数量\n",
    "\n",
    "row_sums = conf_mx.sum(axis=1, keepdims=True)\n",
    "norm_conf_mx = conf_mx / row_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 用0填充对角线 只保留错误，重新绘制\n",
    "np.fill_diagonal(norm_conf_mx, 0)\n",
    "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 每行代表实际类别，每列代表预测类别\n",
    "# 8，9列比较亮，说明许多图片被错误的分类为数字8，9\n",
    "# 类别8，9行也偏亮，说明数字8和9经常会跟其他数字混淆\n",
    "# 有些很暗，比如行1，大多数数字1都被正确的分类，一些和8混淆\n",
    "# 5和3是错误最多的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 结论\n",
    "* 改进数字8和9的分类\n",
    "* 修正数字3和5的混淆\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何优化分类器\n",
    "* 尝试多收集这些数字的训练集\n",
    "* 开发一些新特征来改进分类器\n",
    "* 优化分类器算法\n",
    "* 使用pillow或opencv对图片预处理，让显示模型更突出\n",
    "* 分析单个错误"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_digits(instances, images_per_row=10, **options):\n",
    "    size = 28\n",
    "    images_per_row = min(len(instances), images_per_row)\n",
    "    images = [instance.reshape(size,size) for instance in instances]\n",
    "    n_rows = (len(instances) - 1) // images_per_row + 1\n",
    "    row_images = []\n",
    "    n_empty = n_rows * images_per_row - len(instances)\n",
    "    images.append(np.zeros((size, size * n_empty)))\n",
    "    for row in range(n_rows):\n",
    "        rimages = images[row * images_per_row : (row + 1) * images_per_row]\n",
    "        row_images.append(np.concatenate(rimages, axis=1))\n",
    "    image = np.concatenate(row_images, axis=0)\n",
    "    plt.imshow(image, cmap = matplotlib.cm.binary, **options)\n",
    "    plt.axis(\"off\")\n",
    "\n",
    "\n",
    "# 查看数字3和数字5的例子\n",
    "cl_a, cl_b = 3, 5\n",
    "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n",
    "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]\n",
    "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
    "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.subplot(221); \n",
    "plot_digits(X_aa[:25], images_per_row=5)\n",
    "plt.subplot(222); \n",
    "plot_digits(X_ab[:25], images_per_row=5)\n",
    "plt.subplot(223);\n",
    "plot_digits(X_ba[:25], images_per_row=5)\n",
    "plt.subplot(224); \n",
    "plot_digits(X_bb[:25], images_per_row=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 左侧两个是被分类为3的图片\n",
    "# 右侧两个是被分类为5的图片\n",
    "# 大多数错误分类的图片看起来还是非常明显的错误\n",
    "# 原因：SGD是一个线性模型，它所做就是为每个像素分配一个各个类别的权重，当它看到新的图像，将加权后的像素强度汇总，从而得到一个分数进行分类\n",
    "# 数字3和5在一部分像素位上有区别，所以分类器很容易将其弄混\n",
    "# 通过上面图像，如果书写3 的连接点左移，分类器可能将其分类为数字5，这个分类器对图像位移和旋转敏感\n",
    "# 减少混淆的方法之一，就是对图像进行预处理，确保位于中心位置并且没有旋转"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多标签分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 为每个实例产生多个类别 ，例如 照片识别多个人脸\n",
    "# 分类器经过训练可以识别小红，小白，小军，一张照片 里有 小红，小白\n",
    "# 经过分类器，应该输出[1,1,0]， 是小红，是小白，不是小军\n",
    "# 输出多个二元标签的分类系统称为多标签分类系统"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "y_train_large = ( y_train >= 7 )\n",
    "y_train_odd = (y_train%2 == 1)\n",
    "y_multilabel = np.c_[y_train_large, y_train_odd]\n",
    "\n",
    "knn_clf = KNeighborsClassifier()\n",
    "knn_clf.fit(X_train, y_multilabel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# knn支持多标签分类，不是所有的分类器都支持\n",
    "knn_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # 评估多标签分类器方法很多，方法之一就是测量每个标签的F1分数，或者其他二元分类器指标，然后简单平均\n",
    "# y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3)\n",
    "# f1_score(y_multilabel, y_train_knn_pred, average=\"macro\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多输出分类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 例子：构建一个系统去除图片中的噪声，输入一张有噪声的图片，它将输入一张干净的数字图片，分类器输出是多个标签，一个像素一个标签，每个标签多个值0到255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 增加噪声，目标将图片还原为原始图片 创建训练集和测试集\n",
    "noise = np.random.randint(0,100,(len(X_train), 784))\n",
    "X_train_mod = X_train + noise\n",
    "noise = np.random.randint(0,100,(len(X_test), 784))\n",
    "X_test_mod = X_test + noise\n",
    "y_train_mod = X_train\n",
    "y_test_mod = X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "some_index = 5500\n",
    "plt.subplot(121);plt.imshow(X_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.subplot(122);plt.imshow(y_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "77"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_mod[5500][128]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train[5500][128]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn_clf.fit(X_train_mod, y_train_mod)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   5,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,  31,  74,  43,  13,  24, 254, 116, 166, 253, 172,\n",
       "        183,  89, 230,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,\n",
       "        253, 253,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0, 104, 253, 254, 254, 254, 137,  93,  93,  93,\n",
       "         34,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,  51, 253, 254,   4,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,  45, 253, 254,  95,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0, 101, 253, 254, 253,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 254, 254, 254,\n",
       "        253, 112,  38,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "         16,  90, 254, 253,  42, 197, 114,  12,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,  95, 253, 172,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,  44, 220, 253,  50,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  26,\n",
       "        254,  25,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,  81, 230,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,  17, 203, 126,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0, 253, 254,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "        211,  67,  99,  70,  70, 136, 254,  60,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0, 253, 253, 253, 253, 253, 137,  12,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   5,  19,  46,  29,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0,   0]], dtype=uint8)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicts = knn_clf.predict([X_test_mod[5500]])\n",
    "predicts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(predicts.reshape(28,28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
